#  本example主要用来展示在python中如何使用PyUTSC库实现两种时间类型（UTC时间和地质时间）的编码与解码


import PyUTSC

# UTC基准时间使用UTSC库进行编码解码、层次查询、拓扑查询的操作示例
def utc_test():
    org_time = init_utc()
    print("输入的时间为：")
    myprintdecode(org_time)
    print()
    # 存储编码信息结果
    encode_result = PyUTSC.UTSCElementCode()
    # 编码存储查询结果
    parent_relation_result = PyUTSC.TimeElementCodeStruct(2)
    children_relation_result = PyUTSC.TimeElementCodeStruct(2)
    neighbor_relation_result = PyUTSC.TimeElementCodeStruct(2)
    # 存储解码信息结果
    decode_result = PyUTSC.UTSCTime()
    # 编码
    example_encode(org_time, encode_result)
    # 解码
    example_decode(encode_result, decode_result)
    # 打印编码結果
    print("编码结果为：")
    myprintencode(encode_result)
    print()
    # 打印解码結果
    print("解码结果为：")
    myprintdecode(decode_result)
    print()
    # 层级结构关系查询
    print("父时间查询如下：")
    utsc_struct_query(PyUTSC.Parent, encode_result, parent_relation_result)
    print("子时间查询如下：")
    utsc_struct_query(PyUTSC.Children, encode_result, children_relation_result)
    print("相邻时间查询如下：")
    utsc_struct_query(PyUTSC.Neighbor, encode_result, neighbor_relation_result)
    #  查询两个时间之间的拓扑关系（原始的编码和其相邻层次查询的结果进行拓扑关系查询）
    result = utsc_topo_query(parent_relation_result, neighbor_relation_result, 2)
    print("上述父时间点和其相邻时间段的拓扑关系计算为:：")
    print_topo_query_result(result)

# 地质基准时间使用UTSC库进行编码解码、层次查询、拓扑查询的操作示例
def geo_test():
    org_time_geo = init_geo()
    print("输入的时间为：")
    myprintdecode(org_time_geo)
    print()
    # 存储编码信息结果
    encode_result = PyUTSC.UTSCElementCode()
    # 编码存储查询结果
    parent_relation_result = PyUTSC.TimeElementCodeStruct(2)
    children_relation_result = PyUTSC.TimeElementCodeStruct(2)
    neighbor_relation_result = PyUTSC.TimeElementCodeStruct(2)
    # 存储解码信息结果
    decode_result = PyUTSC.UTSCTime()
    # 编码
    example_encode(org_time_geo, encode_result)
    # 解码
    example_decode(encode_result, decode_result)
    # 打印编码結果
    print("编码结果为：")
    myprintencode(encode_result)
    print()
    # 打印解码結果
    print("解码结果为：")
    myprintdecode(decode_result)
    print()
    # 层级结构关系查询
    print("父时间查询如下：")
    utsc_struct_query(PyUTSC.Parent, encode_result, parent_relation_result)
    print("子时间查询如下：")
    utsc_struct_query(PyUTSC.Children, encode_result, children_relation_result)
    print("相邻时间查询如下：")
    utsc_struct_query(PyUTSC.Neighbor, encode_result, neighbor_relation_result)
    #  查询两个时间之间的拓扑关系（原始的编码和其相邻层次查询的结果进行拓扑关系查询）
    result = utsc_topo_query(parent_relation_result, neighbor_relation_result, 2)
    print("上述父时间点和其相邻时间段的拓扑关系计算为:：")
    print_topo_query_result(result)

# 时间编码
def example_encode(time, code):
    # 初始化结构体
    p_kernel = PyUTSC.CreateKernelObj()

    # 调用方法进行编码
    p_kernel.encode(time, code)

    # 释放结构体
    PyUTSC.DestroyKernelObj(p_kernel)

# 时间解码
def example_decode(code, time):
    # 初始化结构体
    p_kernel = PyUTSC.CreateKernelObj()

    # 调用方法进行解码
    p_kernel.decode(code, time)

    # 释放结构体
    PyUTSC.DestroyKernelObj(p_kernel)

# 打印拓扑查询结果
def print_topo_query_result(type):
    # 定义一个列表来存储拓扑关系字符串
    topo_type_strings = [
        "Before", "After", "StartWith", "StartBy",
        "FinishWith", "FinishBy", "Equal", "OverlapWith",
        "OverlapBy", "Contain", "ContainedBy", "MetBy",
        "MeetWith"
    ]

    # 检查类型编号是否在列表范围内
    if 0 <= type < len(topo_type_strings):
        # 打印对应的拓扑关系字符串
        print(topo_type_strings[type])
    else:
        # 如果类型编号超出范围，打印错误信息
        print("Invalid type")

#  初始化UTC基准时间
def init_utc():
    # 手动初始化UTC类型的时间，2024年2月10日3时2分
    org_time_utc = PyUTSC.UTSCTime(5)
    org_time_utc.system = PyUTSC.UTSCTimeSystemType_UTC
    org_time_utc.setData(0, PyUTSC.UTSCElementType_Year, 2024)
    org_time_utc.setData(1, PyUTSC.UTSCElementType_Month, 2)
    org_time_utc.setData(2, PyUTSC.UTSCElementType_Day, 10)
    org_time_utc.setData(3, PyUTSC.UTSCElementType_Hour, 3)
    org_time_utc.setData(4, PyUTSC.UTSCElementType_Minute, 2)
    return org_time_utc

# 初始化地质基准时间
def init_geo():
    # 手动初始化地质类型的时间，300.123Ma
    org_time_geo = PyUTSC.UTSCTime(2)
    org_time_geo.system = PyUTSC.UTSCTimeSystemType_Geo
    org_time_geo.setData(0, PyUTSC.UTSCElementType_MegaYear, 300)
    org_time_geo.setData(1, PyUTSC.UTSCElementType_KiloYear, 123)
    return org_time_geo

# 时间层级结构关系查询
def utsc_struct_query(type, code, result):
    # 初始化结构体
    p_kernel = PyUTSC.CreateKernelObj()

    # 调用方法进行查询
    p_kernel.structQuery(type, code, result)

    if result._size == 1:
        result_first = result.getDataFromIndex(0)
        decode_result = PyUTSC.UTSCTime()
        p_kernel.decode(result_first, decode_result)
        myprintdecode(decode_result)
        print()
    if result._size == 2:
        result_first = result.getDataFromIndex(0)
        result_second = result.getDataFromIndex(1)
        decode_result_first = PyUTSC.UTSCTime()
        decode_result_second = PyUTSC.UTSCTime()
        p_kernel.decode(result_first, decode_result_first)
        p_kernel.decode(result_second, decode_result_second)
        myprintdecode(decode_result_first)
        print()
        myprintdecode(decode_result_second)
        print()

    # 释放结构体
    PyUTSC.DestroyKernelObj(p_kernel)

# 时间拓扑关系查询
def utsc_topo_query(code1, code2, type):
    # 初始化结构体
    p_kernel = PyUTSC.CreateKernelObj()

    # 调用方法进行查询
    result = p_kernel.topoQuery(code1, code2, type)

    # 释放结构体
    PyUTSC.DestroyKernelObj(p_kernel)

    return result

# 打印编码结果
def myprintdecode(decodetime):
    i = 0
    while decodetime.getElementType(i) != PyUTSC.UTSCElementType_Unknown and i < decodetime.size:
        type = decodetime.getElementType(i)
        data = decodetime.getElementData(i)
        if type == PyUTSC.UTSCElementType_GigaYear:
            print(f"{data}十亿年", end="")
        elif type == PyUTSC.UTSCElementType_MegaYear:
            print(f"{data}百万年", end="")
        elif type == PyUTSC.UTSCElementType_KiloYear:
            print(f"{data}千年", end="")
        elif type == PyUTSC.UTSCElementType_Year:
            print(f"{data}年", end="")
        elif type == PyUTSC.UTSCElementType_Month:
            print(f"{data}月", end="")
        elif type == PyUTSC.UTSCElementType_Day:
            print(f"{data}日", end="")
        elif type == PyUTSC.UTSCElementType_Hour:
            print(f"{data}时", end="")
        elif type == PyUTSC.UTSCElementType_Minute:
            print(f"{data}分", end="")
        elif type == PyUTSC.UTSCElementType_Second:
            print(f"{data}秒", end="")
        elif type == PyUTSC.UTSCElementType_Millisecond:
            print(f"{data}毫秒", end="")
        i += 1

# 打印16位中后N位
def print_last_n_bits(num, n):
    # 计算要打印的掩码
    mask = (1 << n) - 1
    last_n_bits = num & mask

    # 打印最后 n 位
    for i in range(n - 1, -1, -1):
        bit = (last_n_bits >> i) & 1
        print(bit, end='')

# 打印二进制形式结果
def print_binary(n):
    # 打印二进制表示，从最高位到最低位
    for i in range(7, -1, -1):
        bit = (n >> i) & 1
        print(bit, end='')

# 打印解码结果
def myprintencode(encodetime):
    i = 0
    while i < encodetime.size and encodetime.getParams(i) != 0b00000000:
        if i == 0:
            print_last_n_bits(encodetime.signal, 1)
        number = encodetime.getParams(i) & 0x0F
        print_binary(encodetime.getParams(i))
        print_last_n_bits(encodetime.getCodes(i), number)
        i += 1





